package com.shlh.saas.controller;

import com.shlh.saas.common.Result;
import com.shlh.saas.common.UserContext;
import com.shlh.saas.model.dto.LoginDTO;
import com.shlh.saas.model.dto.RegisterDTO;
import com.shlh.saas.model.dto.SmsLoginDTO;
import com.shlh.saas.model.vo.LoginVO;
import com.shlh.saas.service.AuthService;
import jakarta.validation.Valid;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

/**
 * 认证控制器
 */
@RestController
@RequestMapping("/saas/auth")
public class AuthController {

    private static final Logger log = LoggerFactory.getLogger(AuthController.class);

    @Autowired
    private AuthService authService;

    /**
     * 用户注册
     *
     * @param registerDTO 注册信息
     * @return 注册结果
     */
    @PostMapping("/register")
    public Result<Void> register(@RequestBody @Valid RegisterDTO registerDTO) {
        log.info("收到注册请求: username={}, phone={}", 
                 registerDTO.getUsername(), 
                 registerDTO.getPhone());
        
        try {
            authService.register(registerDTO);
            log.info("用户注册成功: {}", registerDTO.getUsername());
            return Result.success("注册成功");
        } catch (Exception e) {
            log.error("用户注册失败: {}", registerDTO.getUsername(), e);
            
            // 提供更详细的错误信息
            String errorMessage = "注册失败: " + e.getMessage();
            
            // 针对特定错误提供友好信息
            if (e.getMessage() != null) {
                if (e.getMessage().contains("用户名已存在")) {
                    errorMessage = "用户名已被使用，请更换";
                } else if (e.getMessage().contains("手机号已被注册")) {
                    errorMessage = "手机号已被注册";
                } else if (e.getMessage().contains("验证码不正确或已过期")) {
                    errorMessage = "验证码不正确或已过期";
                } else if (e.getMessage().contains("Duplicate entry")) {
                    // MySQL唯一键冲突错误
                    if (e.getMessage().contains("username")) {
                        errorMessage = "用户名已被使用，请更换";
                    } else if (e.getMessage().contains("phone")) {
                        errorMessage = "手机号已被注册";
                    } else {
                        errorMessage = "该用户信息已存在";
                    }
                }
            }
            
            return Result.error(errorMessage);
        }
    }

    /**
     * 密码登录
     *
     * @param loginDTO 登录信息
     * @return 登录结果
     */
    @PostMapping("/login")
    public Result<LoginVO> login(@RequestBody @Valid LoginDTO loginDTO) {
        try {
            log.info("收到登录请求: username={}", loginDTO.getUsername());
            LoginVO loginVO = authService.login(loginDTO);
            log.info("登录成功: username={}, userId={}", loginDTO.getUsername(), loginVO.getId());
            return Result.success(loginVO);
        } catch (Exception e) {
            log.error("登录失败: username={}, 错误: {}", loginDTO.getUsername(), e.getMessage(), e);
            return Result.error(e.getMessage());
        }
    }

    /**
     * 短信验证码登录
     *
     * @param smsLoginDTO 短信登录信息
     * @return 登录结果
     */
    @PostMapping("/sms/login")
    public Result<LoginVO> smsLogin(@RequestBody @Valid SmsLoginDTO smsLoginDTO) {
        try {
            log.info("收到短信登录请求: mobile={}", smsLoginDTO.getMobile());
            LoginVO loginVO = authService.smsLogin(smsLoginDTO);
            log.info("短信登录成功: mobile={}, userId={}", smsLoginDTO.getMobile(), loginVO.getId());
            return Result.success(loginVO);
        } catch (Exception e) {
            log.error("短信登录失败: mobile={}, 错误: {}", smsLoginDTO.getMobile(), e.getMessage(), e);
            return Result.error(e.getMessage());
        }
    }

    /**
     * 发送短信验证码
     *
     * @param mobile 手机号
     * @return 发送结果
     */
    @PostMapping("/sms-code")
    public Result<Object> sendSmsCode(@RequestParam String mobile) {
        String code = authService.sendSmsCode(mobile);
        if (code != null) {
            return Result.success("验证码发送成功");
        } else {
            return Result.error("验证码发送失败");
        }
    }

    /**
     * 设置密码（已登录用户）
     *
     * @param password 密码
     * @return 设置结果
     */
    @PostMapping("/set-password")
    public Result<Void> setPassword(@RequestParam String password) {
        try {
            // 使用拦截器获取用户信息，由AuthService内部处理
            authService.setPassword(password);
            return Result.success("密码设置成功");
        } catch (Exception e) {
            log.error("设置密码失败", e);
            return Result.error("设置密码失败: " + e.getMessage());
        }
    }

    /**
     * 退出登录
     *
     * @return 退出结果
     */
    @PostMapping("/logout")
    public Result<Void> logout() {
        authService.logout();
        return Result.success("退出成功");
    }

    /**
     * 修改密码
     *
     * @param currentPassword 当前密码
     * @return 修改结果
     */
    @PostMapping("/update-password")
    public Result<Void> updatePassword(@RequestParam String newPassword, @RequestParam String currentPassword) {
        try {
            log.info("收到修改密码请求: currentPassword长度={}, newPassword长度={}", 
                currentPassword != null ? currentPassword.length() : 0,
                newPassword != null ? newPassword.length() : 0);
            
            // 从ThreadLocal获取用户ID
            Long userId = UserContext.getUserId();
            log.info("从ThreadLocal获取的用户ID: {}", userId);
            
            if (userId == null) {
                log.warn("未获取到用户ID，请求被拒绝");
                return Result.error("未登录或登录已过期");
            }
            
            // 验证当前密码并更新为新密码
            log.info("开始验证并更新密码，userId={}", userId);
            boolean success = authService.updatePassword(userId, currentPassword, newPassword);
            
            if (success) {
                log.info("密码修改成功");
                return Result.success("密码修改成功");
            } else {
                log.warn("当前密码验证失败");
                return Result.error("当前密码验证失败");
            }
        } catch (Exception e) {
            log.error("修改密码时发生异常", e);
            return Result.error("修改密码失败: " + e.getMessage());
        }
    }
    
    /**
     * 直接重置密码（不需要验证当前密码）
     *
     * @param password 新密码
     * @param username 用户名（可选）
     * @param phone 手机号（可选）
     * @return 修改结果
     */
    @PostMapping("/reset-password")
    public Result<Void> resetPassword(@RequestParam String password, 
                                   @RequestParam(required = false) String username,
                                   @RequestParam(required = false) String phone) {
        try {
            log.info("收到直接重置密码请求: password长度={}, username={}, phone={}", 
                password != null ? password.length() : 0, username, phone);
            
            // 检查密码
            if (password == null || password.length() < 6) {
                return Result.error("密码长度不能少于6位");
            }
            
            // 执行重置密码操作
            boolean success = authService.resetPassword(password, username, phone);
            
            if (success) {
                log.info("密码重置成功");
                return Result.success("密码重置成功");
            } else {
                log.warn("密码重置失败");
                return Result.error("密码重置失败，用户不存在");
            }
        } catch (Exception e) {
            log.error("重置密码时发生异常", e);
            return Result.error(e.getMessage());
        }
    }

    /**
     * 刷新Token
     * 
     * @return 新的Token
     */
    @PostMapping("/refresh-token")
    public Result<String> refreshToken() {
        try {
            // 刷新token，用户ID通过拦截器从token中获取
            String newToken = authService.refreshToken();
            if (newToken != null) {
                return Result.success(newToken, "Token刷新成功");
            } else {
                return Result.error("Token刷新失败");
            }
        } catch (Exception e) {
            log.error("Token刷新失败", e);
            return Result.error("Token刷新失败: " + e.getMessage());
        }
    }
}